home *** CD-ROM | disk | FTP | other *** search
/ ShareWare OnLine 2 / ShareWare OnLine Volume 2 (CMS Software)(1993).iso / games2 / rotise12.zip / STANDING.C < prev    next >
Text File  |  1993-03-28  |  7KB  |  245 lines
  1. /* Determine standings */
  2. #include <stdio.h>
  3.  
  4. #ifdef    __TURBOC__
  5. #include <stdlib.h>
  6. #include <io.h>
  7. #endif
  8.  
  9. #include "rotise.h"
  10.  
  11. typedef struct {
  12.     RDB_TEAM *team;
  13.     float value;
  14.     } RANKDATA;
  15.  
  16. extern RDB_TEAM *RotoTeams;                /* roster.c */
  17. extern int RotoTeamCnt;                        /* roster.c */
  18.  
  19. void standings PROTO( (void ));
  20. void wk_standings PROTO( (void) );
  21. void ranka PROTO( (RANKDATA *rank_array, RDB_TEAM *team, int tcnt, double value) );
  22. void rankd PROTO( (RANKDATA *rank_array, RDB_TEAM *team, int tcnt, double value) );
  23. void figger_pnts PROTO( (RANKDATA *rank_array, int which1) );
  24.  
  25. static RANKDATA rank_sb[MAX_TEAMS], rank_hr[MAX_TEAMS], rank_rbi[MAX_TEAMS], rank_avg[MAX_TEAMS],
  26.          rank_w[MAX_TEAMS], rank_ratio[MAX_TEAMS], rank_era[MAX_TEAMS], rank_s[MAX_TEAMS];
  27.  
  28. void standings NOARGLIST
  29. {
  30.     RDB_TEAM *team;
  31.     int tcnt, pnt;
  32.     float tempf;
  33.  
  34.     for ( tcnt = 0, team = RotoTeams; team != NULL; team = team->next, tcnt++ )
  35.     { /* sort all the teams */
  36.         tempf = team->batters.bs_sb;
  37.         ranka( rank_sb, team, tcnt, tempf );
  38.         ranka( rank_rbi, team, tcnt, (double)team->batters.bs_rbi );
  39.         ranka( rank_hr, team, tcnt, (double)team->batters.bs_hr );
  40.         ranka( rank_avg, team, tcnt, avg( &team->batters ) );
  41.  
  42.         ranka( rank_s, team, tcnt, (double)team->pitchers.ps_saved );
  43.         ranka( rank_w, team, tcnt, (double)team->pitchers.ps_won );
  44.         rankd( rank_ratio, team, tcnt, ratio( &team->pitchers ) );
  45.         rankd( rank_era, team, tcnt, era( &team->pitchers ) );
  46.     }
  47.  
  48.     figger_pnts( rank_sb, RANK_SB );
  49.     figger_pnts( rank_hr, RANK_HR );
  50.     figger_pnts( rank_rbi, RANK_RBI );
  51.     figger_pnts( rank_avg, RANK_AVG );
  52.     figger_pnts( rank_w, RANK_WINS );
  53.     figger_pnts( rank_ratio, RANK_RATIO );
  54.     figger_pnts( rank_era, RANK_ERA );
  55.     figger_pnts( rank_s, RANK_SVS );
  56.  
  57.     for ( team = RotoTeams; team != NULL; team = team->next )
  58.     { /* now, figger total points for each team */
  59.         for ( team->totalPnts = pnt = 0; pnt < RANKSIZE; pnt++ )
  60.         { /* add all the points */
  61.             team->totalPnts += team->points[pnt];
  62.         }
  63.     }
  64. }
  65.  
  66. void wk_standings NOARGLIST
  67. {
  68.     RDB_TEAM *team;
  69.     int tcnt, pnt;
  70.     float tempf;
  71.  
  72.     for ( tcnt = 0, team = RotoTeams; team != NULL; team = team->next, tcnt++ )
  73.     { /* sort all the teams */
  74.         tempf = team->bweek.bs_sb;
  75.         ranka( rank_sb, team, tcnt, tempf );
  76.         ranka( rank_rbi, team, tcnt, (double)team->bweek.bs_rbi );
  77.         ranka( rank_hr, team, tcnt, (double)team->bweek.bs_hr );
  78.         ranka( rank_avg, team, tcnt, avg( &team->bweek ) );
  79.  
  80.         ranka( rank_s, team, tcnt, (double)team->pweek.ps_saved );
  81.         ranka( rank_w, team, tcnt, (double)team->pweek.ps_won );
  82.         rankd( rank_ratio, team, tcnt, ratio( &team->pweek ) );
  83.         rankd( rank_era, team, tcnt, era( &team->pweek ) );
  84.     }
  85.  
  86.     figger_pnts( rank_sb, RANK_SB );
  87.     figger_pnts( rank_hr, RANK_HR );
  88.     figger_pnts( rank_rbi, RANK_RBI );
  89.     figger_pnts( rank_avg, RANK_AVG );
  90.     figger_pnts( rank_w, RANK_WINS );
  91.     figger_pnts( rank_ratio, RANK_RATIO );
  92.     figger_pnts( rank_era, RANK_ERA );
  93.     figger_pnts( rank_s, RANK_SVS );
  94.  
  95.     for ( team = RotoTeams; team != NULL; team = team->next )
  96.     { /* now, figger total points for each team */
  97.         for ( team->totalPnts = pnt = 0; pnt < RANKSIZE; pnt++ )
  98.         { /* add all the points */
  99.             team->totalPnts += team->points[pnt];
  100.         }
  101.     }
  102. }
  103.  
  104.  
  105. /* ranka -- rank ascending (higher values get higher ranks) */
  106. void ranka( rank_array, team, tcnt, value )
  107.     RANKDATA *rank_array;
  108.     RDB_TEAM *team;
  109.     int tcnt;
  110.     double value;
  111. {
  112.     int kk;
  113.  
  114.     for ( kk = 0; kk < tcnt; kk++ )
  115.     { /* look thru array to see where this team goes */
  116.         if ( value > rank_array[kk].value )
  117.         { /* okay, so just break */
  118.             break;
  119.         }
  120.     }
  121.  
  122.     /* found a spot, move down the lower ones */
  123.     for ( ; kk < tcnt; tcnt-- )
  124.     { /* move down all the other ones */
  125.         rank_array[tcnt].team = rank_array[tcnt-1].team;
  126.         rank_array[tcnt].value = rank_array[tcnt-1].value;
  127.     }
  128.  
  129.     rank_array[kk].team = team;
  130.     rank_array[kk].value = value;
  131. }
  132.  
  133. /* rankd -- rank descending (lower values get higher ranks) */
  134. void rankd( rank_array, team, tcnt, value )
  135.     RANKDATA *rank_array;
  136.     RDB_TEAM *team;
  137.     int tcnt;
  138.     double value;
  139. {
  140.     int kk;
  141.  
  142.     for ( kk = 0; kk < tcnt; kk++ )
  143.     { /* look thru array to see where this team goes */
  144.         if ( value < rank_array[kk].value )
  145.         { /* okay, so just break */
  146.             break;
  147.         }
  148.     }
  149.  
  150.     /* found a spot, move down the lower ones */
  151.     for ( ; kk < tcnt; tcnt-- )
  152.     { /* move down all the other ones */
  153.         rank_array[tcnt].team = rank_array[tcnt-1].team;
  154.         rank_array[tcnt].value = rank_array[tcnt-1].value;
  155.     }
  156.  
  157.     rank_array[kk].team = team;
  158.     rank_array[kk].value = value;
  159. }
  160.  
  161. void figger_pnts( ranks, rankX )
  162.     RANKDATA *ranks;
  163.     int rankX;
  164. {
  165.     int kk;
  166.     int base;
  167.     float rank;
  168.  
  169.     for( base = 0; base < RotoTeamCnt; )
  170.     { /* base is first of a range of identical values */
  171.         for( kk = base+1; kk < RotoTeamCnt; ++kk )
  172.         { /* Find end of range */
  173.             if ( ranks[kk].value != ranks[base].value )
  174.                 break;
  175.         }
  176.  
  177.         /* Calculate ranking for each value in the range */
  178.         rank = (float)RotoTeamCnt - ((float)(base + kk -1))/2;
  179.  
  180.         for( ; base != kk; ++base )
  181.         { /* Assign the rankings to the teams */
  182.             ranks[base].team->points[rankX] = rank;
  183.         }
  184.     }
  185. }
  186.  
  187.  
  188. /* print_histogram -- print a histogram of current rankings. */
  189. void print_histogram ARGLIST( ( fP, weekF ) )
  190.     NFARG( FILE        *fP    )                /* File to print histogram into */
  191.      FARG( int        weekF    )                /* If doing for the week */
  192. {
  193.     int    teamN;                            /* Team number */
  194.  
  195.     fprintf( fP, "   # %7s %6s %7s %5s %6s %5s %10s  %14s\n\n",
  196.             "Avg", "HR", "RBI", "SB",
  197.             "W", "Sv", "ERA", "Ratio"
  198.             );
  199.  
  200.     for ( teamN = 0; teamN < RotoTeamCnt; ++teamN )
  201.     {
  202.         if ( weekF )
  203.             fprintf( fP, "  %2d  .%3d/%-3d %2d/%-3d %2d/%-3d %2d/%-3d %2d/%-3d %2d/%-2d %6.3f/%-6.3f %7.4f/%-7.4f\n",
  204.                 RotoTeamCnt - teamN,
  205.                 (int)(rank_avg[teamN].value * 1000),
  206.                         (int)(avg(&rank_avg[teamN].team->batters) * 1000),
  207.                 (int)rank_hr[teamN].value,
  208.                         (int)rank_hr[teamN].team->batters.bs_hr,
  209.                 (int)rank_rbi[teamN].value,
  210.                         (int)rank_rbi[teamN].team->batters.bs_rbi,
  211.                 (int)rank_sb[teamN].value,
  212.                         (int)rank_sb[teamN].team->batters.bs_sb,
  213.                 (int)rank_w[teamN].value,
  214.                         (int)rank_w[teamN].team->pitchers.ps_won,
  215.                 (int)rank_s[teamN].value,
  216.                         (int)rank_s[teamN].team->pitchers.ps_saved,
  217.                 rank_era[teamN].value,
  218.                         era(&rank_era[teamN].team->pitchers),
  219.                 rank_ratio[teamN].value,
  220.                         ratio(&rank_ratio[teamN].team->pitchers)
  221.                     );
  222.         else
  223.             fprintf( fP, "  %2d  .%3d/%-3d %3d/%-2d %3d/%-2d %3d/%-2d %3d/%-2d %2d/%-2d %6.3f/%-6.3f %7.4f/%-7.4f\n",
  224.                 RotoTeamCnt - teamN,
  225.                 (int)(rank_avg[teamN].value * 1000),
  226.                         (int)(avg(&rank_avg[teamN].team->bweek) * 1000),
  227.                 (int)rank_hr[teamN].value,
  228.                         (int)rank_hr[teamN].team->bweek.bs_hr,
  229.                 (int)rank_rbi[teamN].value,
  230.                         (int)rank_rbi[teamN].team->bweek.bs_rbi,
  231.                 (int)rank_sb[teamN].value,
  232.                         (int)rank_sb[teamN].team->bweek.bs_sb,
  233.                 (int)rank_w[teamN].value,
  234.                         (int)rank_w[teamN].team->pweek.ps_won,
  235.                 (int)rank_s[teamN].value,
  236.                         (int)rank_s[teamN].team->pweek.ps_saved,
  237.                 rank_era[teamN].value,
  238.                         era(&rank_era[teamN].team->pweek),
  239.                 rank_ratio[teamN].value,
  240.                         ratio(&rank_ratio[teamN].team->pweek)
  241.                     );
  242.     }
  243. }
  244.  
  245.